// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "net/spdy/spdy_test_util_common.h"

#include <stdint.h>

#include <cstddef>
#include <utility>

#include "base/compiler_specific.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "net/base/host_port_pair.h"
#include "net/cert/ct_policy_enforcer.h"
#include "net/cert/mock_cert_verifier.h"
#include "net/cert/multi_log_ct_verifier.h"
#include "net/http/http_cache.h"
#include "net/http/http_network_session.h"
#include "net/http/http_network_transaction.h"
#include "net/http/http_server_properties_impl.h"
#include "net/socket/socket_test_util.h"
#include "net/socket/ssl_client_socket.h"
#include "net/socket/transport_client_socket_pool.h"
#include "net/spdy/buffered_spdy_framer.h"
#include "net/spdy/spdy_alt_svc_wire_format.h"
#include "net/spdy/spdy_framer.h"
#include "net/spdy/spdy_http_utils.h"
#include "net/spdy/spdy_session.h"
#include "net/spdy/spdy_session_pool.h"
#include "net/spdy/spdy_stream.h"
#include "net/url_request/url_request_job_factory_impl.h"

namespace net {

namespace {

    bool next_proto_is_spdy(NextProto next_proto)
    {
        return next_proto >= kProtoSPDYMinimumVersion && next_proto <= kProtoSPDYMaximumVersion;
    }

    // Parses a URL into the scheme, host, and path components required for a
    // SPDY request.
    void ParseUrl(base::StringPiece url, std::string* scheme, std::string* host,
        std::string* path)
    {
        GURL gurl(url.as_string());
        path->assign(gurl.PathForRequest());
        scheme->assign(gurl.scheme());
        host->assign(gurl.host());
        if (gurl.has_port()) {
            host->append(":");
            host->append(gurl.port());
        }
    }

} // namespace

// Chop a frame into an array of MockWrites.
// |frame| is the frame to chop.
// |num_chunks| is the number of chunks to create.
MockWrite* ChopWriteFrame(const SpdySerializedFrame& frame, int num_chunks)
{
    MockWrite* chunks = new MockWrite[num_chunks];
    int chunk_size = frame.size() / num_chunks;
    for (int index = 0; index < num_chunks; index++) {
        const char* ptr = frame.data() + (index * chunk_size);
        if (index == num_chunks - 1)
            chunk_size += frame.size() % chunk_size; // The last chunk takes the remainder.
        chunks[index] = MockWrite(ASYNC, ptr, chunk_size);
    }
    return chunks;
}

// Adds headers and values to a map.
// |extra_headers| is an array of { name, value } pairs, arranged as strings
// where the even entries are the header names, and the odd entries are the
// header values.
// |headers| gets filled in from |extra_headers|.
void AppendToHeaderBlock(const char* const extra_headers[],
    int extra_header_count,
    SpdyHeaderBlock* headers)
{
    std::string this_header;
    std::string this_value;

    if (!extra_header_count)
        return;

    // Sanity check: Non-NULL header list.
    DCHECK(NULL != extra_headers) << "NULL header value pair list";
    // Sanity check: Non-NULL header map.
    DCHECK(NULL != headers) << "NULL header map";
    // Copy in the headers.
    for (int i = 0; i < extra_header_count; i++) {
        // Sanity check: Non-empty header.
        DCHECK_NE('\0', *extra_headers[i * 2]) << "Empty header value pair";
        this_header = extra_headers[i * 2];
        std::string::size_type header_len = this_header.length();
        if (!header_len)
            continue;
        this_value = extra_headers[1 + (i * 2)];
        std::string new_value;
        if (headers->find(this_header) != headers->end()) {
            // More than one entry in the header.
            // Don't add the header again, just the append to the value,
            // separated by a NULL character.

            // Adjust the value.
            new_value = (*headers)[this_header].as_string();
            // Put in a NULL separator.
            new_value.append(1, '\0');
            // Append the new value.
            new_value += this_value;
        } else {
            // Not a duplicate, just write the value.
            new_value = this_value;
        }
        (*headers)[this_header] = new_value;
    }
}

// Create a MockWrite from the given SpdySerializedFrame.
MockWrite CreateMockWrite(const SpdySerializedFrame& req)
{
    return MockWrite(ASYNC, req.data(), req.size());
}

// Create a MockWrite from the given SpdySerializedFrame and sequence number.
MockWrite CreateMockWrite(const SpdySerializedFrame& req, int seq)
{
    return CreateMockWrite(req, seq, ASYNC);
}

// Create a MockWrite from the given SpdySerializedFrame and sequence number.
MockWrite CreateMockWrite(const SpdySerializedFrame& req,
    int seq,
    IoMode mode)
{
    return MockWrite(mode, req.data(), req.size(), seq);
}

// Create a MockRead from the given SpdySerializedFrame.
MockRead CreateMockRead(const SpdySerializedFrame& resp)
{
    return MockRead(ASYNC, resp.data(), resp.size());
}

// Create a MockRead from the given SpdySerializedFrame and sequence number.
MockRead CreateMockRead(const SpdySerializedFrame& resp, int seq)
{
    return CreateMockRead(resp, seq, ASYNC);
}

// Create a MockRead from the given SpdySerializedFrame and sequence number.
MockRead CreateMockRead(const SpdySerializedFrame& resp, int seq, IoMode mode)
{
    return MockRead(mode, resp.data(), resp.size(), seq);
}

// Combines the given SpdyFrames into the given char array and returns
// the total length.
int CombineFrames(const SpdySerializedFrame** frames,
    int num_frames,
    char* buf,
    int buf_len)
{
    int total_len = 0;
    for (int i = 0; i < num_frames; ++i) {
        total_len += frames[i]->size();
    }
    DCHECK_LE(total_len, buf_len);
    char* ptr = buf;
    for (int i = 0; i < num_frames; ++i) {
        int len = frames[i]->size();
        memcpy(ptr, frames[i]->data(), len);
        ptr += len;
    }
    return total_len;
}

namespace {

    class PriorityGetter : public BufferedSpdyFramerVisitorInterface {
    public:
        PriorityGetter()
            : priority_(0)
        {
        }
        ~PriorityGetter() override { }

        SpdyPriority priority() const
        {
            return priority_;
        }

        void OnError(SpdyFramer::SpdyError error_code) override { }
        void OnStreamError(SpdyStreamId stream_id,
            const std::string& description) override { }
        void OnSynStream(SpdyStreamId stream_id,
            SpdyStreamId associated_stream_id,
            SpdyPriority priority,
            bool fin,
            bool unidirectional,
            const SpdyHeaderBlock& headers) override
        {
            priority_ = priority;
        }
        void OnSynReply(SpdyStreamId stream_id,
            bool fin,
            const SpdyHeaderBlock& headers) override { }
        void OnHeaders(SpdyStreamId stream_id,
            bool has_priority,
            int weight,
            SpdyStreamId parent_stream_id,
            bool exclusive,
            bool fin,
            const SpdyHeaderBlock& headers) override
        {
            if (has_priority) {
                priority_ = Http2WeightToSpdy3Priority(weight);
            }
        }
        void OnDataFrameHeader(SpdyStreamId stream_id,
            size_t length,
            bool fin) override { }
        void OnStreamFrameData(SpdyStreamId stream_id,
            const char* data,
            size_t len) override { }
        void OnStreamEnd(SpdyStreamId stream_id) override { }
        void OnStreamPadding(SpdyStreamId stream_id, size_t len) override { }
        void OnSettings(bool clear_persisted) override { }
        void OnSetting(SpdySettingsIds id, uint8_t flags, uint32_t value) override { }
        void OnPing(SpdyPingId unique_id, bool is_ack) override { }
        void OnRstStream(SpdyStreamId stream_id,
            SpdyRstStreamStatus status) override { }
        void OnGoAway(SpdyStreamId last_accepted_stream_id,
            SpdyGoAwayStatus status,
            base::StringPiece debug_data) override { }
        void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) override { }
        void OnPushPromise(SpdyStreamId stream_id,
            SpdyStreamId promised_stream_id,
            const SpdyHeaderBlock& headers) override { }
        void OnAltSvc(SpdyStreamId stream_id,
            base::StringPiece origin,
            const SpdyAltSvcWireFormat::AlternativeServiceVector&
                altsvc_vector) override { }
        bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override
        {
            return false;
        }

    private:
        SpdyPriority priority_;
    };

} // namespace

bool GetSpdyPriority(SpdyMajorVersion version,
    const SpdySerializedFrame& frame,
    SpdyPriority* priority)
{
    BufferedSpdyFramer framer(version);
    PriorityGetter priority_getter;
    framer.set_visitor(&priority_getter);
    size_t frame_size = frame.size();
    if (framer.ProcessInput(frame.data(), frame_size) != frame_size) {
        return false;
    }
    *priority = priority_getter.priority();
    return true;
}

base::WeakPtr<SpdyStream> CreateStreamSynchronously(
    SpdyStreamType type,
    const base::WeakPtr<SpdySession>& session,
    const GURL& url,
    RequestPriority priority,
    const BoundNetLog& net_log)
{
    SpdyStreamRequest stream_request;
    int rv = stream_request.StartRequest(type, session, url, priority, net_log,
        CompletionCallback());
    return (rv == OK) ? stream_request.ReleaseStream() : base::WeakPtr<SpdyStream>();
}

StreamReleaserCallback::StreamReleaserCallback() { }

StreamReleaserCallback::~StreamReleaserCallback() { }

CompletionCallback StreamReleaserCallback::MakeCallback(
    SpdyStreamRequest* request)
{
    return base::Bind(&StreamReleaserCallback::OnComplete,
        base::Unretained(this),
        request);
}

void StreamReleaserCallback::OnComplete(
    SpdyStreamRequest* request, int result)
{
    if (result == OK)
        request->ReleaseStream()->Cancel();
    SetResult(result);
}

MockECSignatureCreator::MockECSignatureCreator(crypto::ECPrivateKey* key)
    : key_(key)
{
}

bool MockECSignatureCreator::Sign(const uint8_t* data,
    int data_len,
    std::vector<uint8_t>* signature)
{
    std::vector<uint8_t> private_key;
    if (!key_->ExportPrivateKey(&private_key))
        return false;
    std::string head = "fakesignature";
    std::string tail = "/fakesignature";

    signature->clear();
    signature->insert(signature->end(), head.begin(), head.end());
    signature->insert(signature->end(), private_key.begin(), private_key.end());
    signature->insert(signature->end(), '-');
    signature->insert(signature->end(), data, data + data_len);
    signature->insert(signature->end(), tail.begin(), tail.end());
    return true;
}

bool MockECSignatureCreator::DecodeSignature(
    const std::vector<uint8_t>& signature,
    std::vector<uint8_t>* out_raw_sig)
{
    *out_raw_sig = signature;
    return true;
}

MockECSignatureCreatorFactory::MockECSignatureCreatorFactory()
{
    crypto::ECSignatureCreator::SetFactoryForTesting(this);
}

MockECSignatureCreatorFactory::~MockECSignatureCreatorFactory()
{
    crypto::ECSignatureCreator::SetFactoryForTesting(nullptr);
}

std::unique_ptr<crypto::ECSignatureCreator>
MockECSignatureCreatorFactory::Create(crypto::ECPrivateKey* key)
{
    return base::MakeUnique<MockECSignatureCreator>(key);
}

SpdySessionDependencies::SpdySessionDependencies(NextProto protocol)
    : SpdySessionDependencies(protocol, ProxyService::CreateDirect())
{
}

SpdySessionDependencies::SpdySessionDependencies(
    NextProto protocol,
    std::unique_ptr<ProxyService> proxy_service)
    : host_resolver(new MockCachingHostResolver)
    , cert_verifier(new MockCertVerifier)
    , channel_id_service(nullptr)
    , transport_security_state(new TransportSecurityState)
    , cert_transparency_verifier(new MultiLogCTVerifier)
    , ct_policy_enforcer(new CTPolicyEnforcer)
    , proxy_service(std::move(proxy_service))
    , ssl_config_service(new SSLConfigServiceDefaults)
    , socket_factory(new MockClientSocketFactory)
    , http_auth_handler_factory(
          HttpAuthHandlerFactory::CreateDefault(host_resolver.get()))
    , http_server_properties(new HttpServerPropertiesImpl)
    , enable_ip_pooling(true)
    , enable_ping(false)
    , enable_user_alternate_protocol_ports(false)
    , enable_npn(false)
    , enable_priority_dependencies(true)
    , enable_spdy31(true)
    , enable_quic(false)
    , protocol(protocol)
    , session_max_recv_window_size(
          SpdySession::GetDefaultInitialWindowSize(protocol))
    , stream_max_recv_window_size(
          SpdySession::GetDefaultInitialWindowSize(protocol))
    , time_func(&base::TimeTicks::Now)
    , enable_http2_alternative_service_with_different_host(false)
    , net_log(NULL)
{
    DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;

    // Note: The CancelledTransaction test does cleanup by running all
    // tasks in the message loop (RunAllPending).  Unfortunately, that
    // doesn't clean up tasks on the host resolver thread; and
    // TCPConnectJob is currently not cancellable.  Using synchronous
    // lookups allows the test to shutdown cleanly.  Until we have
    // cancellable TCPConnectJobs, use synchronous lookups.
    host_resolver->set_synchronous_mode(true);
}

SpdySessionDependencies::~SpdySessionDependencies() { }

// static
std::unique_ptr<HttpNetworkSession> SpdySessionDependencies::SpdyCreateSession(
    SpdySessionDependencies* session_deps)
{
    HttpNetworkSession::Params params = CreateSessionParams(session_deps);
    params.client_socket_factory = session_deps->socket_factory.get();
    std::unique_ptr<HttpNetworkSession> http_session(
        new HttpNetworkSession(params));
    SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
    pool_peer.SetEnableSendingInitialData(false);
    return http_session;
}

// static
HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
    SpdySessionDependencies* session_deps)
{
    DCHECK(next_proto_is_spdy(session_deps->protocol)) << "Invalid protocol: " << session_deps->protocol;

    HttpNetworkSession::Params params;
    params.host_resolver = session_deps->host_resolver.get();
    params.cert_verifier = session_deps->cert_verifier.get();
    params.channel_id_service = session_deps->channel_id_service.get();
    params.transport_security_state = session_deps->transport_security_state.get();
    params.cert_transparency_verifier = session_deps->cert_transparency_verifier.get();
    params.ct_policy_enforcer = session_deps->ct_policy_enforcer.get();
    params.proxy_service = session_deps->proxy_service.get();
    params.ssl_config_service = session_deps->ssl_config_service.get();
    params.http_auth_handler_factory = session_deps->http_auth_handler_factory.get();
    params.http_server_properties = session_deps->http_server_properties.get();
    params.enable_spdy_ping_based_connection_checking = session_deps->enable_ping;
    params.enable_user_alternate_protocol_ports = session_deps->enable_user_alternate_protocol_ports;
    params.enable_npn = session_deps->enable_npn;
    params.enable_priority_dependencies = session_deps->enable_priority_dependencies;
    params.enable_spdy31 = session_deps->enable_spdy31;
    params.enable_quic = session_deps->enable_quic;
    params.spdy_default_protocol = session_deps->protocol;
    params.spdy_session_max_recv_window_size = session_deps->session_max_recv_window_size;
    params.spdy_stream_max_recv_window_size = session_deps->stream_max_recv_window_size;
    params.time_func = session_deps->time_func;
    params.proxy_delegate = session_deps->proxy_delegate.get();
    params.enable_http2_alternative_service_with_different_host = session_deps->enable_http2_alternative_service_with_different_host;
    params.net_log = session_deps->net_log;
    return params;
}

SpdyURLRequestContext::SpdyURLRequestContext(NextProto protocol)
    : storage_(this)
{
    DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;

    storage_.set_host_resolver(
        std::unique_ptr<HostResolver>(new MockHostResolver));
    storage_.set_cert_verifier(base::WrapUnique(new MockCertVerifier));
    storage_.set_transport_security_state(
        base::WrapUnique(new TransportSecurityState));
    storage_.set_proxy_service(ProxyService::CreateDirect());
    storage_.set_ssl_config_service(new SSLConfigServiceDefaults);
    storage_.set_http_auth_handler_factory(
        HttpAuthHandlerFactory::CreateDefault(host_resolver()));
    storage_.set_http_server_properties(
        std::unique_ptr<HttpServerProperties>(new HttpServerPropertiesImpl()));
    storage_.set_job_factory(base::WrapUnique(new URLRequestJobFactoryImpl()));
    HttpNetworkSession::Params params;
    params.client_socket_factory = &socket_factory_;
    params.host_resolver = host_resolver();
    params.cert_verifier = cert_verifier();
    params.transport_security_state = transport_security_state();
    params.proxy_service = proxy_service();
    params.ssl_config_service = ssl_config_service();
    params.http_auth_handler_factory = http_auth_handler_factory();
    params.enable_spdy_ping_based_connection_checking = false;
    params.spdy_default_protocol = protocol;
    params.http_server_properties = http_server_properties();
    storage_.set_http_network_session(
        base::WrapUnique(new HttpNetworkSession(params)));
    SpdySessionPoolPeer pool_peer(
        storage_.http_network_session()->spdy_session_pool());
    pool_peer.SetEnableSendingInitialData(false);
    storage_.set_http_transaction_factory(base::WrapUnique(
        new HttpCache(storage_.http_network_session(),
            HttpCache::DefaultBackend::InMemory(0), false)));
}

SpdyURLRequestContext::~SpdyURLRequestContext()
{
    AssertNoURLRequests();
}

bool HasSpdySession(SpdySessionPool* pool, const SpdySessionKey& key)
{
    return static_cast<bool>(
        pool->FindAvailableSession(key, GURL(), BoundNetLog()));
}

namespace {

    base::WeakPtr<SpdySession> CreateSpdySessionHelper(
        HttpNetworkSession* http_session,
        const SpdySessionKey& key,
        const BoundNetLog& net_log,
        Error expected_status,
        bool is_secure)
    {
        EXPECT_FALSE(HasSpdySession(http_session->spdy_session_pool(), key));

        scoped_refptr<TransportSocketParams> transport_params(
            new TransportSocketParams(
                key.host_port_pair(), false, OnHostResolutionCallback(),
                TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));

        std::unique_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
        TestCompletionCallback callback;

        int rv = ERR_UNEXPECTED;
        if (is_secure) {
            SSLConfig ssl_config;
            scoped_refptr<SSLSocketParams> ssl_params(
                new SSLSocketParams(transport_params,
                    NULL,
                    NULL,
                    key.host_port_pair(),
                    ssl_config,
                    key.privacy_mode(),
                    0,
                    false));
            rv = connection->Init(
                key.host_port_pair().ToString(), ssl_params, MEDIUM,
                ClientSocketPool::RespectLimits::ENABLED, callback.callback(),
                http_session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL),
                net_log);
        } else {
            rv = connection->Init(key.host_port_pair().ToString(), transport_params,
                MEDIUM, ClientSocketPool::RespectLimits::ENABLED,
                callback.callback(),
                http_session->GetTransportSocketPool(
                    HttpNetworkSession::NORMAL_SOCKET_POOL),
                net_log);
        }

        if (rv == ERR_IO_PENDING)
            rv = callback.WaitForResult();

        EXPECT_EQ(OK, rv);

        base::WeakPtr<SpdySession> spdy_session = http_session->spdy_session_pool()->CreateAvailableSessionFromSocket(
            key, std::move(connection), net_log, OK, is_secure);
        // Failure is reported asynchronously.
        EXPECT_TRUE(spdy_session);
        EXPECT_TRUE(HasSpdySession(http_session->spdy_session_pool(), key));
        return spdy_session;
    }

} // namespace

base::WeakPtr<SpdySession> CreateInsecureSpdySession(
    HttpNetworkSession* http_session,
    const SpdySessionKey& key,
    const BoundNetLog& net_log)
{
    return CreateSpdySessionHelper(http_session, key, net_log,
        OK, false /* is_secure */);
}

base::WeakPtr<SpdySession> TryCreateInsecureSpdySessionExpectingFailure(
    HttpNetworkSession* http_session,
    const SpdySessionKey& key,
    Error expected_error,
    const BoundNetLog& net_log)
{
    DCHECK_LT(expected_error, ERR_IO_PENDING);
    return CreateSpdySessionHelper(http_session, key, net_log,
        expected_error, false /* is_secure */);
}

base::WeakPtr<SpdySession> CreateSecureSpdySession(
    HttpNetworkSession* http_session,
    const SpdySessionKey& key,
    const BoundNetLog& net_log)
{
    return CreateSpdySessionHelper(http_session, key, net_log,
        OK, true /* is_secure */);
}

namespace {

    // A ClientSocket used for CreateFakeSpdySession() below.
    class FakeSpdySessionClientSocket : public MockClientSocket {
    public:
        explicit FakeSpdySessionClientSocket(int read_result)
            : MockClientSocket(BoundNetLog())
            , read_result_(read_result)
        {
        }

        ~FakeSpdySessionClientSocket() override { }

        int Read(IOBuffer* buf,
            int buf_len,
            const CompletionCallback& callback) override
        {
            return read_result_;
        }

        int Write(IOBuffer* buf,
            int buf_len,
            const CompletionCallback& callback) override
        {
            return ERR_IO_PENDING;
        }

        // Return kProtoUnknown to use the pool's default protocol.
        NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }

        // The functions below are not expected to be called.

        int Connect(const CompletionCallback& callback) override
        {
            ADD_FAILURE();
            return ERR_UNEXPECTED;
        }

        bool WasEverUsed() const override
        {
            ADD_FAILURE();
            return false;
        }

        bool WasNpnNegotiated() const override
        {
            ADD_FAILURE();
            return false;
        }

        bool GetSSLInfo(SSLInfo* ssl_info) override
        {
            ADD_FAILURE();
            return false;
        }

        int64_t GetTotalReceivedBytes() const override
        {
            NOTIMPLEMENTED();
            return 0;
        }

    private:
        int read_result_;
    };

    base::WeakPtr<SpdySession> CreateFakeSpdySessionHelper(
        SpdySessionPool* pool,
        const SpdySessionKey& key,
        Error expected_status)
    {
        EXPECT_NE(expected_status, ERR_IO_PENDING);
        EXPECT_FALSE(HasSpdySession(pool, key));
        std::unique_ptr<ClientSocketHandle> handle(new ClientSocketHandle());
        handle->SetSocket(
            std::unique_ptr<StreamSocket>(new FakeSpdySessionClientSocket(
                expected_status == OK ? ERR_IO_PENDING : expected_status)));
        base::WeakPtr<SpdySession> spdy_session = pool->CreateAvailableSessionFromSocket(
            key, std::move(handle), BoundNetLog(), OK, true /* is_secure */);
        // Failure is reported asynchronously.
        EXPECT_TRUE(spdy_session);
        EXPECT_TRUE(HasSpdySession(pool, key));
        return spdy_session;
    }

} // namespace

base::WeakPtr<SpdySession> CreateFakeSpdySession(SpdySessionPool* pool,
    const SpdySessionKey& key)
{
    return CreateFakeSpdySessionHelper(pool, key, OK);
}

base::WeakPtr<SpdySession> TryCreateFakeSpdySessionExpectingFailure(
    SpdySessionPool* pool,
    const SpdySessionKey& key,
    Error expected_error)
{
    DCHECK_LT(expected_error, ERR_IO_PENDING);
    return CreateFakeSpdySessionHelper(pool, key, expected_error);
}

SpdySessionPoolPeer::SpdySessionPoolPeer(SpdySessionPool* pool)
    : pool_(pool)
{
}

void SpdySessionPoolPeer::RemoveAliases(const SpdySessionKey& key)
{
    pool_->RemoveAliases(key);
}

void SpdySessionPoolPeer::DisableDomainAuthenticationVerification()
{
    pool_->verify_domain_authentication_ = false;
}

void SpdySessionPoolPeer::SetEnableSendingInitialData(bool enabled)
{
    pool_->enable_sending_initial_data_ = enabled;
}

void SpdySessionPoolPeer::SetSessionMaxRecvWindowSize(size_t window)
{
    pool_->session_max_recv_window_size_ = window;
}

void SpdySessionPoolPeer::SetStreamInitialRecvWindowSize(size_t window)
{
    pool_->stream_max_recv_window_size_ = window;
}

SpdyTestUtil::SpdyTestUtil(NextProto protocol, bool dependency_priorities)
    : protocol_(protocol)
    , spdy_version_(NextProtoToSpdyMajorVersion(protocol))
    , headerless_spdy_framer_(spdy_version_)
    , request_spdy_framer_(spdy_version_)
    , response_spdy_framer_(spdy_version_)
    , default_url_(GURL(kDefaultUrl))
    , dependency_priorities_(dependency_priorities)
{
    DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
}

SpdyTestUtil::~SpdyTestUtil() { }

void SpdyTestUtil::AddUrlToHeaderBlock(base::StringPiece url,
    SpdyHeaderBlock* headers) const
{
    std::string scheme, host, path;
    ParseUrl(url, &scheme, &host, &path);
    (*headers)[GetHostKey()] = host;
    (*headers)[GetSchemeKey()] = scheme;
    (*headers)[GetPathKey()] = path;
}

SpdyHeaderBlock SpdyTestUtil::ConstructGetHeaderBlock(
    base::StringPiece url) const
{
    return ConstructHeaderBlock("GET", url, NULL);
}

SpdyHeaderBlock SpdyTestUtil::ConstructGetHeaderBlockForProxy(
    base::StringPiece url) const
{
    return ConstructGetHeaderBlock(url);
}

SpdyHeaderBlock SpdyTestUtil::ConstructHeadHeaderBlock(
    base::StringPiece url,
    int64_t content_length) const
{
    return ConstructHeaderBlock("HEAD", url, nullptr);
}

SpdyHeaderBlock SpdyTestUtil::ConstructPostHeaderBlock(
    base::StringPiece url,
    int64_t content_length) const
{
    return ConstructHeaderBlock("POST", url, &content_length);
}

SpdyHeaderBlock SpdyTestUtil::ConstructPutHeaderBlock(
    base::StringPiece url,
    int64_t content_length) const
{
    return ConstructHeaderBlock("PUT", url, &content_length);
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyFrame(
    const SpdyHeaderInfo& header_info,
    SpdyHeaderBlock headers) const
{
    BufferedSpdyFramer framer(spdy_version_);
    SpdySerializedFrame* frame = NULL;
    switch (header_info.kind) {
    case DATA:
        frame = framer.CreateDataFrame(header_info.id, header_info.data,
            header_info.data_length,
            header_info.data_flags);
        break;
    case SYN_STREAM:
        frame = framer.CreateSynStream(
            header_info.id, header_info.assoc_id, header_info.priority,
            header_info.control_flags, std::move(headers));
        break;
    case SYN_REPLY:
        frame = framer.CreateSynReply(header_info.id, header_info.control_flags,
            std::move(headers));
        break;
    case RST_STREAM:
        frame = framer.CreateRstStream(header_info.id, header_info.status);
        break;
    case HEADERS:
        frame = framer.CreateHeaders(header_info.id, header_info.control_flags,
            header_info.weight, std::move(headers));
        break;
    default:
        ADD_FAILURE();
        break;
    }
    return frame;
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyFrame(
    const SpdyHeaderInfo& header_info,
    const char* const extra_headers[],
    int extra_header_count,
    const char* const tail_headers[],
    int tail_header_count) const
{
    SpdyHeaderBlock headers;
    AppendToHeaderBlock(extra_headers, extra_header_count, &headers);
    if (tail_headers && tail_header_count)
        AppendToHeaderBlock(tail_headers, tail_header_count, &headers);
    return ConstructSpdyFrame(header_info, std::move(headers));
}

std::string SpdyTestUtil::ConstructSpdyReplyString(
    const SpdyHeaderBlock& headers) const
{
    std::string reply_string;
    for (SpdyHeaderBlock::const_iterator it = headers.begin();
         it != headers.end(); ++it) {
        std::string key = it->first.as_string();
        // Remove leading colon from "special" headers (for SPDY3 and
        // above).
        if (spdy_version() >= SPDY3 && key[0] == ':')
            key = key.substr(1);
        for (const std::string& value :
            base::SplitString(it->second, base::StringPiece("\0", 1),
                base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
            reply_string += key + ": " + value + "\n";
        }
    }
    return reply_string;
}

// TODO(jgraettinger): Eliminate uses of this method in tests (prefer
// SpdySettingsIR).
SpdySerializedFrame* SpdyTestUtil::ConstructSpdySettings(
    const SettingsMap& settings)
{
    SpdySettingsIR settings_ir;
    for (SettingsMap::const_iterator it = settings.begin();
         it != settings.end();
         ++it) {
        settings_ir.AddSetting(
            it->first,
            (it->second.first & SETTINGS_FLAG_PLEASE_PERSIST) != 0,
            (it->second.first & SETTINGS_FLAG_PERSISTED) != 0,
            it->second.second);
    }
    return new SpdySerializedFrame(
        headerless_spdy_framer_.SerializeFrame(settings_ir));
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdySettingsAck()
{
    char kEmptyWrite[] = "";

    if (spdy_version() > SPDY3) {
        SpdySettingsIR settings_ir;
        settings_ir.set_is_ack(true);
        return new SpdySerializedFrame(
            headerless_spdy_framer_.SerializeFrame(settings_ir));
    }
    // No settings ACK write occurs. Create an empty placeholder write.
    return new SpdySerializedFrame(kEmptyWrite, 0, false);
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyPing(uint32_t ping_id,
    bool is_ack)
{
    SpdyPingIR ping_ir(ping_id);
    ping_ir.set_is_ack(is_ack);
    return new SpdySerializedFrame(
        headerless_spdy_framer_.SerializeFrame(ping_ir));
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyGoAway()
{
    return ConstructSpdyGoAway(0);
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyGoAway(
    SpdyStreamId last_good_stream_id)
{
    SpdyGoAwayIR go_ir(last_good_stream_id, GOAWAY_OK, "go away");
    return new SpdySerializedFrame(headerless_spdy_framer_.SerializeFrame(go_ir));
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyGoAway(
    SpdyStreamId last_good_stream_id,
    SpdyGoAwayStatus status,
    const std::string& desc)
{
    SpdyGoAwayIR go_ir(last_good_stream_id, status, desc);
    return new SpdySerializedFrame(headerless_spdy_framer_.SerializeFrame(go_ir));
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyWindowUpdate(
    const SpdyStreamId stream_id,
    uint32_t delta_window_size)
{
    SpdyWindowUpdateIR update_ir(stream_id, delta_window_size);
    return new SpdySerializedFrame(
        headerless_spdy_framer_.SerializeFrame(update_ir));
}

// TODO(jgraettinger): Eliminate uses of this method in tests (prefer
// SpdyRstStreamIR).
SpdySerializedFrame* SpdyTestUtil::ConstructSpdyRstStream(
    SpdyStreamId stream_id,
    SpdyRstStreamStatus status)
{
    SpdyRstStreamIR rst_ir(stream_id, status);
    return new SpdySerializedFrame(
        headerless_spdy_framer_.SerializeRstStream(rst_ir));
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyGet(
    const char* const url,
    SpdyStreamId stream_id,
    RequestPriority request_priority)
{
    SpdyHeaderBlock block(ConstructGetHeaderBlock(url));
    return ConstructSpdySyn(stream_id, std::move(block), request_priority, true);
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyGet(
    const char* const extra_headers[],
    int extra_header_count,
    int stream_id,
    RequestPriority request_priority,
    bool direct)
{
    SpdyHeaderBlock block;
    MaybeAddVersionHeader(&block);
    block[GetMethodKey()] = "GET";
    AddUrlToHeaderBlock(default_url_.spec(), &block);
    AppendToHeaderBlock(extra_headers, extra_header_count, &block);
    return ConstructSpdySyn(stream_id, std::move(block), request_priority, true);
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyConnect(
    const char* const extra_headers[],
    int extra_header_count,
    int stream_id,
    RequestPriority priority,
    const HostPortPair& host_port_pair)
{
    SpdyHeaderBlock block;
    MaybeAddVersionHeader(&block);
    block[GetMethodKey()] = "CONNECT";
    if (spdy_version() < HTTP2) {
        block[GetHostKey()] = (host_port_pair.port() == 443)
            ? host_port_pair.host()
            : host_port_pair.ToString();
        block[GetPathKey()] = host_port_pair.ToString();
    } else {
        block[GetHostKey()] = host_port_pair.ToString();
    }
    AppendToHeaderBlock(extra_headers, extra_header_count, &block);
    return ConstructSpdySyn(stream_id, std::move(block), priority, false);
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyPush(
    const char* const extra_headers[],
    int extra_header_count,
    int stream_id,
    int associated_stream_id,
    const char* url)
{
    if (spdy_version() < HTTP2) {
        SpdyHeaderBlock header_block;
        header_block["hello"] = "bye";
        header_block[GetStatusKey()] = "200";
        header_block[GetVersionKey()] = "HTTP/1.1";
        AddUrlToHeaderBlock(url, &header_block);
        AppendToHeaderBlock(extra_headers, extra_header_count, &header_block);
        SpdySynStreamIR syn_stream(stream_id, std::move(header_block));
        syn_stream.set_associated_to_stream_id(associated_stream_id);
        return new SpdySerializedFrame(
            response_spdy_framer_.SerializeFrame(syn_stream));
    } else {
        SpdyHeaderBlock push_promise_header_block;
        AddUrlToHeaderBlock(url, &push_promise_header_block);
        SpdyPushPromiseIR push_promise(associated_stream_id, stream_id,
            std::move(push_promise_header_block));
        SpdySerializedFrame push_promise_frame(
            response_spdy_framer_.SerializeFrame(push_promise));

        SpdyHeaderBlock headers_header_block;
        headers_header_block[GetStatusKey()] = "200";
        headers_header_block["hello"] = "bye";
        AppendToHeaderBlock(extra_headers, extra_header_count,
            &headers_header_block);
        SpdyHeadersIR headers(stream_id, std::move(headers_header_block));
        SpdySerializedFrame headers_frame(
            response_spdy_framer_.SerializeFrame(headers));

        int joint_data_size = push_promise_frame.size() + headers_frame.size();
        std::unique_ptr<char[]> data(new char[joint_data_size]);
        const SpdySerializedFrame* frames[2] = {
            &push_promise_frame,
            &headers_frame,
        };
        int combined_size = CombineFrames(frames, arraysize(frames), data.get(), joint_data_size);
        DCHECK_EQ(combined_size, joint_data_size);
        return new SpdySerializedFrame(data.release(), joint_data_size, true);
    }
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyPush(
    const char* const extra_headers[],
    int extra_header_count,
    int stream_id,
    int associated_stream_id,
    const char* url,
    const char* status,
    const char* location)
{
    if (spdy_version() < HTTP2) {
        SpdyHeaderBlock header_block;
        header_block["hello"] = "bye";
        header_block[GetStatusKey()] = status;
        header_block[GetVersionKey()] = "HTTP/1.1";
        header_block["location"] = location;
        AddUrlToHeaderBlock(url, &header_block);
        AppendToHeaderBlock(extra_headers, extra_header_count, &header_block);
        SpdySynStreamIR syn_stream(stream_id, std::move(header_block));
        syn_stream.set_associated_to_stream_id(associated_stream_id);
        return new SpdySerializedFrame(
            response_spdy_framer_.SerializeFrame(syn_stream));
    } else {
        SpdyHeaderBlock push_promise_header_block;
        AddUrlToHeaderBlock(url, &push_promise_header_block);
        SpdyPushPromiseIR push_promise(associated_stream_id, stream_id,
            std::move(push_promise_header_block));
        SpdySerializedFrame push_promise_frame(
            response_spdy_framer_.SerializeFrame(push_promise));

        SpdyHeaderBlock headers_header_block;
        headers_header_block["hello"] = "bye";
        headers_header_block[GetStatusKey()] = status;
        headers_header_block["location"] = location;
        AppendToHeaderBlock(extra_headers, extra_header_count,
            &headers_header_block);
        SpdyHeadersIR headers(stream_id, std::move(headers_header_block));
        SpdySerializedFrame headers_frame(
            response_spdy_framer_.SerializeFrame(headers));

        int joint_data_size = push_promise_frame.size() + headers_frame.size();
        std::unique_ptr<char[]> data(new char[joint_data_size]);
        const SpdySerializedFrame* frames[2] = {
            &push_promise_frame,
            &headers_frame,
        };
        int combined_size = CombineFrames(frames, arraysize(frames), data.get(), joint_data_size);
        DCHECK_EQ(combined_size, joint_data_size);
        return new SpdySerializedFrame(data.release(), joint_data_size, true);
    }
}

SpdySerializedFrame* SpdyTestUtil::ConstructInitialSpdyPushFrame(
    SpdyHeaderBlock headers,
    int stream_id,
    int associated_stream_id)
{
    if (spdy_version() < HTTP2) {
        SpdySynStreamIR syn_stream(stream_id, std::move(headers));
        syn_stream.set_associated_to_stream_id(associated_stream_id);
        SetPriority(LOWEST, &syn_stream);
        return new SpdySerializedFrame(
            response_spdy_framer_.SerializeFrame(syn_stream));
    } else {
        SpdyPushPromiseIR push_promise(associated_stream_id, stream_id,
            std::move(headers));
        return new SpdySerializedFrame(
            response_spdy_framer_.SerializeFrame(push_promise));
    }
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyPushHeaders(
    int stream_id,
    const char* const extra_headers[],
    int extra_header_count)
{
    SpdyHeaderBlock header_block;
    header_block[GetStatusKey()] = "200";
    MaybeAddVersionHeader(&header_block);
    AppendToHeaderBlock(extra_headers, extra_header_count, &header_block);
    SpdyHeadersIR headers(stream_id, std::move(header_block));
    return new SpdySerializedFrame(response_spdy_framer_.SerializeFrame(headers));
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyResponseHeaders(
    int stream_id,
    SpdyHeaderBlock headers,
    bool fin)
{
    SpdyHeadersIR spdy_headers(stream_id, std::move(headers));
    spdy_headers.set_fin(fin);
    return new SpdySerializedFrame(
        response_spdy_framer_.SerializeFrame(spdy_headers));
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdySyn(int stream_id,
    SpdyHeaderBlock block,
    RequestPriority priority,
    bool fin)
{
    // Get the stream id of the next highest priority request
    // (most recent request of the same priority, or last request of
    // an earlier priority).
    // Note that this is a duplicate of the logic in Http2PriorityDependencies
    // (slightly transformed as this is based on RequestPriority and that logic
    // on SpdyPriority, but only slightly transformed) and hence tests using
    // this function do not effectively test that logic.
    // That logic is tested by the Http2PriorityDependencies unit tests.
    int parent_stream_id = 0;
    for (int q = priority; q <= HIGHEST; ++q) {
        if (!priority_to_stream_id_list_[q].empty()) {
            parent_stream_id = priority_to_stream_id_list_[q].back();
            break;
        }
    }

    priority_to_stream_id_list_[priority].push_back(stream_id);

    if (protocol_ < kProtoHTTP2) {
        SpdySynStreamIR syn_stream(stream_id, std::move(block));
        syn_stream.set_priority(
            ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
        syn_stream.set_fin(fin);
        return new SpdySerializedFrame(
            request_spdy_framer_.SerializeFrame(syn_stream));
    } else {
        SpdyHeadersIR headers(stream_id, std::move(block));
        headers.set_has_priority(true);
        headers.set_weight(Spdy3PriorityToHttp2Weight(
            ConvertRequestPriorityToSpdyPriority(priority, spdy_version())));
        if (dependency_priorities_) {
            headers.set_parent_stream_id(parent_stream_id);
            headers.set_exclusive(true);
        }
        headers.set_fin(fin);
        return new SpdySerializedFrame(
            request_spdy_framer_.SerializeFrame(headers));
    }
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyReply(int stream_id,
    SpdyHeaderBlock headers)
{
    if (protocol_ < kProtoHTTP2) {
        SpdySynReplyIR syn_reply(stream_id, std::move(headers));
        return new SpdySerializedFrame(
            response_spdy_framer_.SerializeFrame(syn_reply));
    } else {
        SpdyHeadersIR reply(stream_id, std::move(headers));
        return new SpdySerializedFrame(response_spdy_framer_.SerializeFrame(reply));
    }
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdySynReplyError(
    const char* const status,
    const char* const* const extra_headers,
    int extra_header_count,
    int stream_id)
{
    SpdyHeaderBlock block;
    block[GetStatusKey()] = status;
    MaybeAddVersionHeader(&block);
    block["hello"] = "bye";
    AppendToHeaderBlock(extra_headers, extra_header_count, &block);

    return ConstructSpdyReply(stream_id, std::move(block));
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyGetSynReplyRedirect(
    int stream_id)
{
    static const char* const kExtraHeaders[] = {
        "location",
        "http://www.foo.com/index.php",
    };
    return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
        arraysize(kExtraHeaders) / 2, stream_id);
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdySynReplyError(int stream_id)
{
    return ConstructSpdySynReplyError("500 Internal Server Error", NULL, 0, 1);
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyGetSynReply(
    const char* const extra_headers[],
    int extra_header_count,
    int stream_id)
{
    SpdyHeaderBlock block;
    block[GetStatusKey()] = "200";
    MaybeAddVersionHeader(&block);
    block["hello"] = "bye";
    AppendToHeaderBlock(extra_headers, extra_header_count, &block);

    return ConstructSpdyReply(stream_id, std::move(block));
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyPost(
    const char* url,
    SpdyStreamId stream_id,
    int64_t content_length,
    RequestPriority priority,
    const char* const extra_headers[],
    int extra_header_count)
{
    SpdyHeaderBlock block(ConstructPostHeaderBlock(url, content_length));
    AppendToHeaderBlock(extra_headers, extra_header_count, &block);
    return ConstructSpdySyn(stream_id, std::move(block), priority, false);
}

SpdySerializedFrame* SpdyTestUtil::ConstructChunkedSpdyPost(
    const char* const extra_headers[],
    int extra_header_count)
{
    SpdyHeaderBlock block;
    MaybeAddVersionHeader(&block);
    block[GetMethodKey()] = "POST";
    AddUrlToHeaderBlock(default_url_.spec(), &block);
    AppendToHeaderBlock(extra_headers, extra_header_count, &block);
    return ConstructSpdySyn(1, std::move(block), LOWEST, false);
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyPostSynReply(
    const char* const extra_headers[],
    int extra_header_count)
{
    // TODO(jgraettinger): Remove this method.
    return ConstructSpdyGetSynReply(extra_headers, extra_header_count, 1);
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id,
    bool fin)
{
    SpdyFramer framer(spdy_version_);
    SpdyDataIR data_ir(stream_id,
        base::StringPiece(kUploadData, kUploadDataSize));
    data_ir.set_fin(fin);
    return new SpdySerializedFrame(framer.SerializeData(data_ir));
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id,
    const char* data,
    uint32_t len,
    bool fin)
{
    SpdyFramer framer(spdy_version_);
    SpdyDataIR data_ir(stream_id, base::StringPiece(data, len));
    data_ir.set_fin(fin);
    return new SpdySerializedFrame(framer.SerializeData(data_ir));
}

SpdySerializedFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id,
    const char* data,
    uint32_t len,
    bool fin,
    int padding_length)
{
    SpdyFramer framer(spdy_version_);
    SpdyDataIR data_ir(stream_id, base::StringPiece(data, len));
    data_ir.set_fin(fin);
    data_ir.set_padding_len(padding_length);
    return new SpdySerializedFrame(framer.SerializeData(data_ir));
}

SpdySerializedFrame* SpdyTestUtil::ConstructWrappedSpdyFrame(
    const std::unique_ptr<SpdySerializedFrame>& frame,
    int stream_id)
{
    return ConstructSpdyBodyFrame(stream_id, frame->data(),
        frame->size(), false);
}

SpdySerializedFrame SpdyTestUtil::SerializeFrame(const SpdyFrameIR& frame_ir)
{
    return headerless_spdy_framer_.SerializeFrame(frame_ir);
}

void SpdyTestUtil::UpdateWithStreamDestruction(int stream_id)
{
    for (auto priority_it = priority_to_stream_id_list_.begin();
         priority_it != priority_to_stream_id_list_.end(); ++priority_it) {
        for (auto stream_it = priority_it->second.begin();
             stream_it != priority_it->second.end(); ++stream_it) {
            if (*stream_it == stream_id) {
                priority_it->second.erase(stream_it);
                return;
            }
        }
    }
    NOTREACHED();
}

const char* SpdyTestUtil::GetMethodKey() const
{
    return ":method";
}

const char* SpdyTestUtil::GetStatusKey() const
{
    return ":status";
}

const char* SpdyTestUtil::GetHostKey() const
{
    if (protocol_ < kProtoHTTP2)
        return ":host";
    else
        return ":authority";
}

const char* SpdyTestUtil::GetSchemeKey() const
{
    return ":scheme";
}

const char* SpdyTestUtil::GetVersionKey() const
{
    return ":version";
}

const char* SpdyTestUtil::GetPathKey() const
{
    return ":path";
}

SpdyHeaderBlock SpdyTestUtil::ConstructHeaderBlock(
    base::StringPiece method,
    base::StringPiece url,
    int64_t* content_length) const
{
    std::string scheme, host, path;
    ParseUrl(url.data(), &scheme, &host, &path);
    SpdyHeaderBlock headers;
    if (include_version_header()) {
        headers[GetVersionKey()] = "HTTP/1.1";
    }
    headers[GetMethodKey()] = method.as_string();
    headers[GetHostKey()] = host.c_str();
    headers[GetSchemeKey()] = scheme.c_str();
    headers[GetPathKey()] = path.c_str();
    if (content_length) {
        std::string length_str = base::Int64ToString(*content_length);
        headers["content-length"] = length_str;
    }
    return headers;
}

void SpdyTestUtil::MaybeAddVersionHeader(SpdyHeaderBlock* block) const
{
    if (include_version_header()) {
        (*block)[GetVersionKey()] = "HTTP/1.1";
    }
}

void SpdyTestUtil::SetPriority(RequestPriority priority,
    SpdySynStreamIR* ir) const
{
    ir->set_priority(ConvertRequestPriorityToSpdyPriority(
        priority, spdy_version()));
}

} // namespace net
